package Ioc_DI;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Component
class Di {
    public void p() {
        System.out.println("di");
    }
}

@RestController
@RequestMapping("ioc/")
public class ioc {
    @Autowired
    Di d1;
    @RequestMapping("i1")
    public void i1() {
        System.out.println("i1 start");
        System.out.println(d1);
        d1.p();
    }

    /**
     * ioc  Inversion of Control
     * 使用类注入的方式来初始化，这样即使类发生了变化，和他相联系的类也不用更改，就达到了解耦
     * DI Dependency Injection
     * 依赖注入：当容器在运行的时候动态的添加程序所需要的资源
     * 当将类交给spring管理之后，在需要使用的时候通过@Autowired注解来注入对象，默认使用的是一个无参的构造函数
     * 不能够手动实例化一个对象，因为spring只对他管理的bean对象进行依赖注入，如果不是通过spring来获取
     * ioc对象，那么即使有autowired也不会自动注入
     */


//    public static void main(String[] args) {
//        Tire t = new Tire(20);
//        Bottom b = new Bottom(t);
//        Framework f = new Framework(b);
//        Car c = new Car(f);
//        System.out.println("car run");
//        ioc i1 = new ioc();
//        System.out.println(i1.i2);
//    }
}
class Car {
    Framework framework;

    public Car(Framework f) {
        framework = f;
        System.out.println("Car init");
    }
}

class Framework {
    Bottom bottom;
    public Framework(Bottom b) {
        bottom = b;
        System.out.println("Framework init");
    }
}


class Bottom {
    Tire tire;
    public Bottom(Tire t) {
        tire = t;
        System.out.println("bottom init");
    }
}

class Tire {
    int size;

    public Tire(int s) {
        size = s;
        System.out.println("tire init");
    }

    public void t() {
    }
}



